//
//  Hipnotic Entity Set for Qoole
//  By Matt Ayres
//

include "quake.ent"

class "Trap"
class "HFunc"
class "HTrigger"

entity "" "Info-><break>" ""
{
}

entity "" "Misc-><break>" ""
{
}

entity "" "Monster-><break>" ""
{
}

entity "" "Weapon-><break>" ""
{
}

entity "" "Sound-><break>" ""
{
}

entity "info_rotate" "Info->Rotate" "Used as the point of rotation for rotatable objects"
{
	"origin"	notuser
}

flagdef protate_flags {
	1	"Use rate based on rotate value"
	2	"Use angle based on angle value"
	4	"Stop train and wait to be retriggered"
	8	"Stop rotating train and wait to be retriggered"
	16	"Stop rotating train while waiting to be triggered"
	32	"Cause damage based on dmg value"
	64	"Set all targets damage to dmg value"
}

entity "path_rotate" "Misc->Path Rotate" ""
{
	"origin"	notuser
	"spawnflags"	protate_flags
	"noise"		str		"Name of the sound to play when train stops"
	"noise1"	str		"Name of the sound to play when train moves"
	"event"		str		"Target to trigger when train arrives at path_rotate"
}

flagdef "frotate_flags"
{
	1	"Allow rotation to be toggled on/off"
	2	"Start entity spinning when spawned"
}

entity "func_rotate_entity" "HFunc->Rotate Entity" "Creates an entity that continually rotates"
{
	"spawnflags"	frotate_flags
	"rotate"	int		"Rate to rotate"
	"target"	str		"Center of rotation"
	"speed"		int		"How long entity takes to spin up"
	"targetname"	str		"Its trigger name"
	model
}

typedef "rotate_sounds"
{
	1	"rachet metal"
}

entity "func_rotate_train" "HFunc->Rotate Train" ""
{
	"noise"		str		"Name of the sound to play when train stops"
	"noise1"	str		"Name of the sound to play when train moves"
	"path"		str		"First path_rotate"
	"deathtype"	str		"Message display when player is killed by the train"
	"speed"		int (100)
	"dmg"		int (0)
	"sounds"	rotate_sounds
	"targetname"	str		"Its trigger name"
	model
}

entity "rotate_object" "Misc->Rotate Object" "Defines an object to be rotated"
{
	"origin"	notuser
	"targetname"	str		"Its trigger name"
}

flagdef "rdoor_flags"
{
	1		"Reopen after closing"
	256		"Don't appear if skill 0 (easy)"
	512		"Don't appear if skill 1 (medium)"
	1024		"Don't appear if skill 2 (hard and nightmare)"
	2048		"Don't appear if deathmatch game"
}

typedef "rdoor_sounds"
{
	1	"medieval"
	2	"metal"
	3	"base"
}

entity "func_rotate_door" "HFunc->Rotate Door" "Creates a door that rotates between two positions around a point of rotation"
{
	"spawnflags"	rdoor_flags
	"dmg"		int (2)		"Damage done when blocked"
	"speed"		int		"How much time it takes to rotate"
	"sounds"	rdoor_sounds (1)
	"targetname"	str		"Its trigger name"
	model
}

entity "func_clock" "HFunc->Clock" "Creates one hand of a clock"
{
	"angle"		int		"Direction clock is facing"
	"cnt"		int		"Time to start at"
	"count"		int (60)	"Number of seconds to make a full revolution"
	"targetname"	str		"Its trigger name"
	model
}

flagdefs "movewall_flags"
{
	1	"Display brush"
	2	"Cause damage to player when touched"
	4	"Make wall non-solid"
}

entity "func_movewall" "HFunc->Move Wall" "Used to emulate collision on rotating objects"
{
	"spawnflags"	movewall_flags
	"dmg"		int		"Damage cuased when touched or blocked"
	"targetname"	str		"Its trigger name"
	model
}

entity "func_train2" "HFunc->Train 2" "Modified func_train entity"
{
	"sounds"	int (1)		"Sound it makes when activated"
	"speed"		int (100)	"Speed at which it moves (default:100)"
	"dmg"		int (2)		"Damage done on crush (default:2)"
	"targetname"	str		"Its trigger name"
	"target"	str		"Trigger name of its first path_corner destination"
	"noise"		str		"Name of the sound to play when train stops"
	"noise1"	str		"Name of the sound to play when train moves"
	model
}

entity "func_pushable" "HFunc->Pushable" "Pushable walls.  Not quite working"
{
	"target"	str		"Trigger name of target"
	model
}

entity "path_follow" "Misc->Path Follow" ""
{
	"origin"	notuser
	"targetname"	str		"Its trigger name"
}

entity "path_follow2" "Misc->Path Follow 2" ""
{
	"origin"	notuser
	"targetname"	str		"Its trigger name"
}

entity "item_artificat_wetsuit" "Item->Wetsuit" "Player takes no damage from electrical attacks and swims faster for 30 seconds"
{
	"origin"	notuser
}

entity "item_hornofconjuring" "Item->Horn of Conjuring" "Horn of Conjuring"
{
	"origin"	notuser
}

entity "item_artificat_empathy_shields" "Item->Empathy Shields" ""
{
	"origin"	notuser
}

entity "weapon_mjolnir" "Weapon->weapon_mjolnir" ""
{
	"origin"	notuser
}

entity "weapon_laser_gun" "Weapon->Laser Gun" ""
{
	"origin"	notuser
}

entity "weapon_proximity_gun" "Weapon->Proximity Gun" ""
{
	"origin"	notuser
}

entity "trap_spike_mine" "Trap->Spike Mine" ""
{
	"origin"	notuser
	"targetname"	str		"Its trigger name"
}

entity "trap_lightning_triggered" "Trap->Lightning (triggered)" ""
{
	"origin"	notuser
	"mangle"	notuser
	"wait"		float (1.0)	"How long to wait between blasts"
	"nextthink"	int		"Delay before firing first lightning"
	"dmg"		int (30)	"Damage lightning should inflict"
	"duration"	float (0.1)	"How long each lightning attack should last"
	"targetname"	str		"Its trigger name"
}

entity "trap_lightning" "Trap->Lightning" ""
{
	"origin"	notuser
	"mangle"	notuser
	"wait"		float (1.0)	"How long to wait between blasts"
	"nextthink"	int		"Delay before firing first lightning"
	"dmg"		int (30)	"Damage lightning should inflict"
	"duration"	float (0.1)	"How long each lightning attack should last"
	"targetname"	str		"Its trigger name"
}

typedef "switch"
{
	0	"Initially off"
	1	"Initially on"
}

entity "trap_lightning_switched" "Trap->Lightning (switched)" ""
{
	"origin"	notuser
	"mangle"	notuser
	"wait"		float (1.0)	"How long to wait between blasts"
	"nextthink"	int		"Delay before firing first lightning"
	"dmg"		int (30)	"Damage lightning should inflict"
	"duration"	float (0.1)	"How long each lightning attack should last"
	"state"		switch
	"targetname"	str		"Its trigger name"
}

entity "trap_tesla_coil" "Trap->Tesla Coil" ""
{
	"origin"	notuser
	"wait"		float (0.5)	"How long build up should be"
	"dmg"		int (5)		"Damage tesla coil should inflict"
	"duration"	float (0.0)	"How long each lightning attack should last"
	"distance"	int (600)	"How far the tesla coil should reach"
	"state"		switch
	"count"		int (2)		"Number of people to target"
}

entity "trap_gods_wrath" "Trap->Gods Wrath" ""
{
	"origin"	notuser
	"dmg"		int (5)		"Damage lightning should inflict"
	"duration"	float (0.0)	"How long each lightning attack should last"
	"distance"	int (600)	"How far god's wrath should reach"
	"delay"		float (5.0)	"How long to wait until god clams down"
	"count"		int (2)		"Number of people to target"
}

flagdef "well_flags"
{
	1	"Half pull for players wearing wetsuit"
}

entity "trap_gravity_well" "Trap->Gravity Well" ""
{
	"origin"	notuser
	"distance"	int (600)	"How far gravity well should reach"
	"count"		int (2)		"Number of people to target"
	"speed"		int (210)	"How strong the pull is"
	"dmg"		int (10000)	"How much damage to do each touch"
	"spawnflags"	well_flags
}

flagdef "shooter_spawnflags"
{
	1	"Superspike"
	2	"Laser"
	4	"Lavaball"
	8	"Rocket"
	16	"Silent"
}

entity "trap_spikeshooter" "Trap->Spikes Shooter" "Shoots spikes (nails)"
{
	"origin"	notuser
	"angle"		int		"Angle the trap fires at"
	"wait"		int		"Time between shots"
	"spawnflags"	shooter_flags	""
	"nextthink"	float		"Delay before firing first spike (so shots can be skeygered)"
	"targetname"	str		"Its trigger name"
}

entity "trap_shooter" "Trap->Shooter" "Fires nails without needing to be triggered."
{
	"origin"	notuser
	"angle"		int		"Angle the trap fires at"
	"wait"		int		"Time between shots"
	"spawnflags"	shooter_flags	""
	"nextthink"	float		"Delay before firing first spike (so shots can be skeygered)"
	"targetname"	str		"Its trigger name"
}

entity "trap_switched_shooter" "Trap->Shooter (switched)" ""
{
	"origin"	notuser
	"angle"		int		"Angle the trap fires at"
	"wait"		int		"Time between shots"
	"spawnflags"	shooter_flags
	"nextthink"	float		"Delay before firing first spike (so shots can be skeygered)"
	"state"		switch (0)
	"targetname"	str		"Its trigger name"
}

typedef "attenuation"
{
	-1	"No attenuation"
	1	"Normal attenuation"
	2	"Idle attenuation"
	3	"Static attenuation"

entity "play_sound_triggered" "Misc->Play Sound (triggered)" "Play a sound when it is used"
{
	"origin"	notuser
	"volume"	float (1.0)	"How loud"
	"noise"		str		"Sound to play"
	"impulse"	int (0)		"Channel on which to play sound"
	"speed"		attenuation	"Attenuation factor"
	"targetname"	str		"Its trigger name"
}

entity "play_sound" "Misc->Play Sound" "Play a sound on a periodic basis"
{
	"origin"	notuser
	"volume"	float (1.0)	"How loud"
	"noise"		str		"Sound to play"
	"wait"		int (20)	"Random time between sounds"
	"delay"		int (2)		"Minimum delay between sounds"
	"impulse"	int (0)		"Channel on which to play sound"
	"speed"		attenuation	"Attenuation factor"
	"targetname"	str		"Its trigger name"
}

entity "random_thunder" "Misc->Random Thunder" ""
{
	"origin"	notuser
	"volume"	float (1.0)	"How loud"
	"wait"		int (20)	"Random time between sounds"
	"delay"		int (2)		"Minimum delay between sounds"
	"speed"		attenuation	"Attenuation factor"
	"targetname"	str		"Its trigger name"
}

entity "random_thunder_triggered" "Misc->Random Thunder (triggered)" ""
{
	"origin"	notuser
	"volume"	float (1.0)	"How loud"
	"speed"		attenuation	"Attenuation factor"
	"targetname"	str		"Its trigger name"
}

entity "ambient_humming" "Sound->Humming" "Humming ambient sound"
{
	"origin"	notuser
	"volume"	float (0.5)	"How loud it should be"
}

entity "ambient_running_water" "Sound->Running Water" "Running water ambient sound"
{
	"origin"	notuser
	"volume"	float (0.5)	"How loud it should be"
}

entity "ambient_fan_blowing" "Sound->Fan Blowing" "Fan blowing ambient sound"
{
	"origin"	notuser
	"volume"	float (0.5)	"How loud it should be"
}

entity "ambient_waterfall" "Sound->Waterfall" "Waterfall ambient sound"
{
	"origin"	notuser
	"volume"	float (0.5)	"How loud it should be"
}

entity "ambient_rifpower" "Sound->Riftpower" "Riftpower ambient sound"
{
	"origin"	notuser
	"volume"	float (0.5)	"How loud it should be"
}

flagdef "particle_flags"
{
	1	"Only activate field when count is equal to cnt"
}

entity "func_particlefield" "HFunc->Particle Field" "Creates a brief particle flash"
{
	"spawnflags"	particle_flags
	"cnt"		int		"Count to activate"
	"color"		int (192)	"Color of the particles"
	"count"		int (2)		"Density of the particles"
	"noise"		str		"Sound to play when triggered (do not use looping sounds)"
	"dmg"		int		"Amount of damage when touched"
	"targetname"	str		"Its trigger name"
	model
}

flagdef "togglewall_flags"
{
	1	"Wall doesn't block until triggered"
}

entity "func_togglewall" "HFunc->Toggle Wall" "Creates an invisible wall that can be toggled on/off"
{
	"spawnflags"	togglewall_flags
	"noise"		str		"Name of the sound to play when train stops"
	"noise1"	str		"Name of the sound to play when train moves"
	"dmg"		int		"Amount of damage when touched"
	"targetname"	str		"Its trigger name"
	model
}

entity "func_earthquake" "HFunc->Earthquake" "Causes an earthquake.  Triggers targets"
{
	"dmg"		float (0.8)	"Duration of the earthquake"
	"targetname"	str		"Its trigger name"
	"target"	str		"Target to trigger"
	model
}

entity "func_rubble" "HFunc->Rubble (random)" "Spawns random sized rubble when triggered"
{
	"count"		int (1)		"Number of pieces of rubble to spawn"
	"targetname"	str		"Its trigger name"
	model
}

entity "func_rubble1" "HFunc->Rubble (small)" "Spawns small rubble when triggered"
{
	"count"		int (1)		"Number of pieces of rubble to spawn"
	"targetname"	str		"Its trigger name"
	model
}

entity "func_rubble2" "HFunc->Rubble (medium)" "Spawns medium rubble when triggered"
{
	"count"		int (1)		"Number of pieces of rubble to spawn"
	"targetname"	str		"Its trigger name"
	model
}

entity "func_rubble3" "HFunc->Rubble (large)" "Spawns large rubble when triggered"
{
	"count"		int (1)		"Number of pieces of rubble to spawn"
	"targetname"	str		"Its trigger name"
	model
}

entity "func_breakawaywall" "HFunc->Breakaway Wall" "Special walltype that removes itself when triggered"
{
	"targetname"	str		"Its trigger name"
	model
}

flagdef "exploder_flags"
{
	1	"Spawn particles"
}

entity "func_exploder" "HFunc->Exploder" "Spawns an explosion when triggered"
{
	"spawnflags"	exploder_flags
	"dmg"		int (120)	"Damage to cause"
	"volume"	float (1.0)	"Volume at which to play explosions"
	"speed"		attenuation (1)
	"targetname"	str		"Its trigger name"
	model
}

entity "func_multi_exploder" "HFunc->Multi Exploder" "Spawns an explosion when triggered"
{
	"dmg"		int (120)	"Damage to cause"
	"delay"		float (0.0)	"Delay before exploding"
	"duration"	float (1.0)	"How long to explode for"
	"wait"		float (0.25)	"Time between each explosion"
	"volume"	float (0.5)	"Volume at which to play explosions"
	"speed"		attenuation (1)
	"targetname"	str		"Its trigger name"
	model
}

entity "wallsprite" "Misc->Wall Sprite" "Places a sprite on a wall"
{
	"origin"	notuser
	"mangle"	notuser
	"model"		str		"Sprite to place on wall"
}

entity "effect_teleport" "Misc->Effect Teleport" "Creates a teleport effect when triggered"
{
	"origin"	notuser
	"targetname"	str		"Its trigger name"
}

flagdef "finale_flags"
{
	1	"Use the current player as decoy location"
	2	"No decoy, only the camera"
}

entity "effect_finale" "Misc->Effect Finale" "Starts the finale sequence"
{
	"origin"	notuser
	"spawnflags"	finale_flags
	"target"	str		"Camera to go to"
	"mdl"		str		"Path corner to run to"
	"spawnfunction"	str		"Next routine to run"
	"delay"		float		"Time to wait until running routine"
}

entity "info_startendtext" "Info->Start End Text" "Start the end text if this level has any"
{
	"origin"	notuser
	"targetname"	str		"Its trigger name"
}

entity "monster_armagon" "Monster->Armagon" ""
{
	"origin"	notuser
	"angle"		notuser
	"spawnflags"	monster_spawnflags
}

entity "monster_gremlin" "Monster->Gremlin" ""
{
	"origin"	notuser
	"angle"		notuser
	"spawnflags"	monster_spawnflags
}

entity "monster_scourge" "Monster->Centroids" ""
{
	"origin"	notuser
	"angle"		notuser
	"spawnflags"	monster_spawnflags
}

entity "monster_decoy" "Monster->Decoy" ""
{
	"origin"	notuser
	"angle"		notuser
	"spawnflags"	monster_spawnflags
}

entity "func_spawn" "Func->Spawn" ""
{
	"spawnflags"	int
	"spawnclassname"	str	"Should contain same value as spawnfunction"
	"spawnfunction"	str		"Monster to spawn"
	"angle"		notuser
	"target"	str
	"spawnsilent"	int (1)		"Set this to 0 if you want silent spawn"
	"spawnmulti"	int (0)		"Set this to 1 if you want this spawn to be reoccuring"
	model
}

entity "func_spawn_small" "Func->Spawn Small" ""
{
	"spawnflags"	int
	"spawnclassname"	str	"Should contain same value as spawnfunction"
	"spawnfunction"	str		"Monster to spawn"
	"angle"		notuser
	"target"	str
	"spawnsilent"	int (1)		"Set this to 0 if you want silent spawn"
	"spawnmulti"	int (0)		"Set this to 1 if you want this spawn to be reoccuring"
	model
}

flagdef "counter_flags"
{
	1	"Switches on and off each time triggered"
	2	"Repeat infinitly"
	4	"Only increment when triggered"
	8	"Reset to 0 when restarted"
	16	"Generate random values from 1 to 'count'"
	32	"Continue until counter reaches 'count'"
	64	"Start on"
}

entity "func_counter" "HFunc->Counter" ""
{
	"spawnflags"	counter_flags
	"count"		int (10)	"How many times to repeat the count"
	"wait"		float (1.0)	"Length of time between each trigger event"
	"delay"		float		"How much time to wait before firing"
	"targetname"	str		"Its trigger name"
	"target"	str		"Target to trigger"
	model
}

entity "func_oncount" "HFunc->On Count" ""
{
	"targetname"	str		"Its trigger name"
	"count"		int (1)		"Specifies the value to trigger on"
	"delay"		float		"How mcuh time to wait before firing"
	model
}

entity "trigger_damagethreshold" "HTrigger->Damage Threshold" ""
{
	"spawnflags"	int
	"health"	int (60)	"How much damage must occur before trigger fire"
	"targetname"	str		"Its trigger name"
	"target"	str		"Trigger name of its target"
	model
}

typedef "multiple_sounds"
{
	1	"Secret"
	2	"Beep Beep"
	3	"Large switch"
}

entity "trigger_multiple" "HTrigger->Multiple" "Triggers action (can be retriggered)"
{
	"killtarget"	str		"Kills something [for triggering monster events] (optional)"
	"targetname"	str		"Its trigger name"
	"target"	str		"Trigger name of target"
	"sounds"	multiple_sounds	"Sound made when triggered"
	"wait"		int		"Delay before retrigger"
	"cnt"		int		"How many times it can be triggered"
	"delay"		int		"Delay before action is triggered"
	"health"	int		"if > 1, must be killed to trigger, if == 0, walk-over trigger"
	"message"	str		"String displayed when triggered"
	model
}

entity "trigger_hurt" "HTrigger->Hurt" "Any object touching this will be hurt"
{
	"targetname"	str		"Its trigger name"
	"cnt"		int		"How many times to trigger"
	model
}

entity "trigger_monsterjump" "HTrigger->Monster Jump" ""
{
	"targetname"	str		"Its trigger name"
	"speed"		int (200)	"Speed thrown forward"
	"height"	int (200)	"Speed thrown upwards"
	"cnt"		int		"How many times to trigger"
	model
}

entity "trigger_usekey" "HTrigger->Use Key" ""
{
	"spawnflags"	int
	"message"	str
	"targetname"	str		"Its trigger name"
	model
}

entity "trigger_remove" "HTrigger->Remove" ""
{
	"spawnflags"	int
	"targetname"	str		"Its trigger name"
	model
}

entity "trigger_setgravity" "HTrigger->Set Gravity" "Set the gravity of a player"
{
	"gravity"	int (0)		"Gravity (1 = none, 101 = normal, 1000 = high)"
	"targetname"	str		"Its trigger name"
	model
}

entity "trigger_command" "HTrigger->Command" ""
{
	"message"	str		"Command to send to the console"
	"targetname"	str		"Its trigger name"
	model
}

entity "info_command" "Info->Command" ""
{
	"origin"	notuser
	"message"	str		"Command to send to the console"
	"targetname"	str		"Its trigger name"
}

entity "trigger_decoy_use" "HTrigger->Decoy Use" ""
{
	"targetname"	str		"Its trigger name"
	model
}

entity "trigger_waterfall" "HTrigger->Waterfall" "Push the player"
{
	"mangle"	notuser
	"speed"		int (50)	"Strength of the push push"
	"count"		int (100)	"Amount of random xy movement"
	"targetname"	str		"Its trigger name"
	model
}

entity "func_bobbingwater" "HFunc->Bobbing Water" "Used to emulated water"
{
	"speed"		float		"How long in seconds it takes the brush to do one full bob"
	"targetname"	str		"Its trigger name"
	model
}
